home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / comm / mail / Mutt089src.lha / Mutt-0.89i-AMIGA / src / help.c < prev    next >
C/C++ Source or Header  |  1998-01-28  |  5KB  |  242 lines
  1. /*
  2.  * Copyright (C) 1996-8 Michael R. Elkins <me@cs.hmc.edu>
  3.  * 
  4.  *     This program is free software; you can redistribute it and/or modify
  5.  *     it under the terms of the GNU General Public License as published by
  6.  *     the Free Software Foundation; either version 2 of the License, or
  7.  *     (at your option) any later version.
  8.  * 
  9.  *     This program is distributed in the hope that it will be useful,
  10.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  *     GNU General Public License for more details.
  13.  * 
  14.  *     You should have received a copy of the GNU General Public License
  15.  *     along with this program; if not, write to the Free Software
  16.  *     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  */ 
  18.  
  19. #define HELP_C
  20.  
  21. #include "mutt.h"
  22. #include "mutt_curses.h"
  23. #include "keymap.h"
  24.  
  25. #include <ctype.h>
  26. #include <string.h>
  27.  
  28. static struct binding_t *help_lookupFunction (int op, int menu)
  29. {
  30.   int i;
  31.   struct binding_t *map;
  32.  
  33.   if (menu != MENU_PAGER)
  34.   {
  35.     /* first look in the generic map for the function */
  36.     for (i = 0; OpGeneric[i].name; i++)
  37.       if (OpGeneric[i].op == op)
  38.     return (&OpGeneric[i]);    
  39.   }
  40.  
  41.   switch (menu)
  42.   {
  43.     case MENU_PAGER:
  44.       map = OpPager;
  45.       break;
  46.     case MENU_MAIN:
  47.       map = OpMain;
  48.       break;
  49.     case MENU_ATTACH:
  50.       map = OpAttach;
  51.       break;
  52.     case MENU_POST:
  53.       map = OpPost;
  54.       break;
  55.     case MENU_FOLDER:
  56.       map = OpBrowser;
  57.       break;
  58.     case MENU_COMPOSE:
  59.       map = OpCompose;
  60.       break;
  61.     case MENU_ALIAS:
  62.       map = OpAlias;
  63.       break;
  64. #ifdef _PGPPATH
  65.     case MENU_PGP:
  66.       map = OpPgp;
  67.       break;
  68. #endif
  69.     default:
  70.       return NULL;
  71.   }
  72.   for (i = 0; map[i].name; i++)
  73.     if (map[i].op == op)
  74.       return (&map[i]);
  75.   return (NULL);
  76. }
  77.  
  78. void mutt_make_help (char *d, size_t dlen, char *txt, int menu, int op)
  79. {
  80.   char buf[SHORT_STRING];
  81.  
  82.   if (km_expand_key (buf, sizeof(buf), km_find_func (menu, op)))
  83.     snprintf (d, dlen, "%s:%s", buf, txt);
  84.   else
  85.     d[0] = 0;
  86. }
  87.  
  88. static void print_macro (FILE *f, const char *macro)
  89. {
  90.   int i;
  91.  
  92.   for (i = 0; *macro && i < COLS - 34; macro++, i++)
  93.   {
  94.     switch (*macro)
  95.     {
  96.       case '\033':
  97.     fputs ("\\e", f);
  98.     i++;
  99.     break;
  100.       case '\n':
  101.     fputs ("\\n", f);
  102.     i++;
  103.     break;
  104.       case '\r':
  105.     fputs ("\\r", f);
  106.     i++;
  107.     break;
  108.       case '\t':
  109.     fputs ("\\t", f);
  110.     i++;
  111.     break;
  112.       default:
  113.     fputc (*macro, f);
  114.     break;
  115.     }
  116.   }
  117. }
  118.  
  119. static void dump_menu (FILE *f, int menu)
  120. {
  121.   struct keymap_t *map;
  122.   struct binding_t *b;
  123.   char buf[SHORT_STRING];
  124.  
  125.   /* browse through the keymap table */
  126.   for (map = Keymaps[menu]; map; map = map->next)
  127.   {
  128.     km_expand_key (buf, sizeof (buf), map);
  129.  
  130.     if (map->op == OP_MACRO)
  131.     {
  132.       fprintf (f, "%s\t%-20s\t", buf, "macro");
  133.       print_macro (f, map->macro);
  134.       fputc ('\n', f);
  135.     }
  136.     else if (map->op != OP_NULL)
  137.     {
  138.       b = help_lookupFunction (map->op, menu);
  139.       fprintf (f, "%s\t%-20s\t%s\n", buf,
  140.           b ? b->name : "UNKNOWN",
  141.           b ? HelpStrings[b->op] : "ERROR: please report this bug");
  142.     }
  143.   }
  144. }
  145.  
  146. static int is_bound (struct keymap_t *map, int op)
  147. {
  148.   for (; map; map = map->next)
  149.     if (map->op == op)
  150.       return 1;
  151.   return 0;
  152. }
  153.  
  154. static void dump_unbound (FILE *f,
  155.               struct binding_t *funcs,
  156.               struct keymap_t *map,
  157.               struct keymap_t *aux)
  158. {
  159.   int i;
  160.  
  161.   for (i = 0; funcs[i].name; i++)
  162.   {
  163.     if (! is_bound (map, funcs[i].op) &&
  164.     (!aux || ! is_bound (aux, funcs[i].op)))
  165.       fprintf (f, "%s\t\t%s\n", funcs[i].name, HelpStrings[funcs[i].op]);
  166.   }
  167. }
  168.  
  169. void mutt_help (int menu)
  170. {
  171.   char t[_POSIX_PATH_MAX];
  172.   char buf[SHORT_STRING];
  173.   char *desc;
  174.   FILE *f;
  175.   struct binding_t *funcs = NULL;
  176.  
  177.   mutt_mktemp (t);
  178.   if ((f = fopen (t, "w")) == NULL)
  179.   {
  180.     mutt_perror (t);
  181.     return;
  182.   }
  183.  
  184.   switch (menu)
  185.   {
  186.     case MENU_PAGER:
  187.       funcs = OpPager;
  188.       desc = "pager";
  189.       break;
  190.     case MENU_MAIN:
  191.       funcs = OpMain;
  192.       desc = "index";
  193.       break;
  194.     case MENU_ATTACH:
  195.       funcs = OpAttach;
  196.       desc = "attach";
  197.       break;
  198.     case MENU_COMPOSE:
  199.       funcs = OpCompose;
  200.       desc = "compose";
  201.       break;
  202.     case MENU_FOLDER:
  203.       funcs = OpBrowser;
  204.       desc = "browser";
  205.       break;
  206.     case MENU_ALIAS:
  207.       funcs = OpAlias;
  208.       desc = "alias";
  209.       break;
  210.     case MENU_POST:
  211.       funcs = OpPost;
  212.       desc = "postponed";
  213.       break;
  214. #ifdef _PGPPATH
  215.     case MENU_PGP:
  216.       funcs = OpPgp;
  217.       desc = "pgp";
  218.       break;
  219. #endif
  220.     default:
  221.       desc = "<UNKNOWN MENU>";
  222.   }
  223.  
  224.   dump_menu (f, menu);
  225.   if (menu != MENU_EDITOR && menu != MENU_PAGER)
  226.   {
  227.     fputs ("\nGeneric bindings:\n\n", f);
  228.     dump_menu (f, MENU_GENERIC);
  229.   }
  230.  
  231.   fputs ("\nUnbound functions:\n\n", f);
  232.   if (funcs)
  233.     dump_unbound (f, funcs, Keymaps[menu], NULL);
  234.   if (menu != MENU_PAGER)
  235.     dump_unbound (f, OpGeneric, Keymaps[MENU_GENERIC], Keymaps[menu]);
  236.  
  237.   fclose (f);
  238.  
  239.   snprintf (buf, sizeof (buf), "Help for %s", desc);
  240.   mutt_do_pager (buf, t, 0);
  241. }
  242.